package mx.ipn.servicios;

import mx.ipn.negocios.facturacion.Facturas;
import mx.ipn.persistencia.FabricaDeDAOs;
import mx.ipn.to.*;

import java.util.Collection;
import java.sql.Date;
import java.sql.Time;

public class Persistencia {
	private static int TIPODEFABRICA;
	private static FabricaDeDAOs fabricaDeDAOs;

	public static TransferObject setTipoDeFabrica(int tipo) {
		TIPODEFABRICA = tipo;

		fabricaDeDAOs = FabricaDeDAOs.getFabricaDeDAOs(TIPODEFABRICA);

		return new TransferObject();
	}

	public static int getTipoDeFabrica() {
		return TIPODEFABRICA;
	}

	/* Direcciones */
	// Estado
	public EstadoTO[] seleccionarEstados() {
		Collection<EstadoTO> coleccion = fabricaDeDAOs.getEstadoDAO()
				.selectEstado();
		return (EstadoTO[]) coleccion.toArray(new EstadoTO[coleccion.size()]);
	}

	public short modificarEstado(EstadoTO estadoTO) {
		return fabricaDeDAOs.getEstadoDAO().updateEstado(estadoTO);
	}

	public boolean agregarEstado(EstadoTO estadoTO) {
		return fabricaDeDAOs.getEstadoDAO().insertEstado(estadoTO);
	}

	// Municipio
	public MunicipioTO seleccionarMunicipiosPorEstado(short idEstado) {
		return fabricaDeDAOs.getMunicipioDAO()
				.selectMunicipioByEstado(idEstado);
	}

	public short modificarMunicipio(MunicipioTO municipioTO) {
		return fabricaDeDAOs.getMunicipioDAO().updateMunicipio(municipioTO);
	}

	public boolean agregarMunicipio(MunicipioTO municipioTO) {
		return fabricaDeDAOs.getMunicipioDAO().insertMunicipio(municipioTO);
	}

	// Colonia
	public ColoniaTO seleccionarColoniasPorMunicipio(int idMunicipio) {
		return fabricaDeDAOs.getColoniaDAO().selectColoniaByMunicipio(
				idMunicipio);
	}

	public short modificarColonia(ColoniaTO coloniaTO) {
		return fabricaDeDAOs.getColoniaDAO().updateColonia(coloniaTO);
	}

	public boolean agregarColonia(ColoniaTO coloniaTO) {
		return fabricaDeDAOs.getColoniaDAO().insertColonia(coloniaTO);
	}

	// Colonia Calle
	public ColoniaCalleTO seleccionarCallesPorColonia(int idColonia) {
		return fabricaDeDAOs.getColoniaCalleDAO().selectColoniaCalleByColonia(
				idColonia);
	}

	public boolean agregarColoniaCalle(ColoniaCalleTO coloniaCalleTO) {
		return fabricaDeDAOs.getColoniaCalleDAO().insertColoniaCalle(
				coloniaCalleTO);
	}

	// Calle
	public short modificarCalle(CalleTO calleTO) {
		return fabricaDeDAOs.getCalleDAO().updateCalle(calleTO);
	}

	public int agregarCalle(CalleTO calleTO) {
		return fabricaDeDAOs.getCalleDAO().insertCalle(calleTO);
	}

	// Direccion
	public DireccionTO seleccionarDireccionesPorColoniaCalle(int idColoniaCalle) {
		return fabricaDeDAOs.getDireccionDAO().selectDireccionByColoniaCalle(
				idColoniaCalle);
	}

	public short modificarDireccion(DireccionTO direccionTO) {
		return fabricaDeDAOs.getDireccionDAO().updateDireccion(direccionTO);
	}

	public boolean agregarDireccion(DireccionTO direccionTO) {
		return fabricaDeDAOs.getDireccionDAO().insertDireccion(direccionTO);
	}

	/* CLIENTE */
	public boolean insertarCliente(ClienteTO clienteTO) {
		return fabricaDeDAOs.getClienteDAO().insertCliente(clienteTO);
	}

	public short borrarCliente(int id) {
		return fabricaDeDAOs.getClienteDAO().deleteCliente(id);
	}

	public short actualizarCliente(ClienteTO clienteTO) {
		return fabricaDeDAOs.getClienteDAO().updateCliente(clienteTO);
	}

	public ClienteTO[] seleccionarClientes() {
		Collection<ClienteTO> coleccion = fabricaDeDAOs.getClienteDAO()
				.selectClientes();
		if (coleccion == null)
			return null;
		return (ClienteTO[]) coleccion.toArray(new ClienteTO[coleccion.size()]);
	}

	public ClienteTO[] seleccionarClientesPorTelefono(String telefono) {
		Collection<ClienteTO> coleccion = fabricaDeDAOs.getClienteDAO()
				.selectClientesByTelefono(telefono);
		if (coleccion == null)
			return null;
		return (ClienteTO[]) coleccion.toArray(new ClienteTO[coleccion.size()]);
	}

	public ClienteTO[] seleccionarClientesPorApellidoPaterno(String apellido) {
		Collection<ClienteTO> coleccion = fabricaDeDAOs.getClienteDAO()
				.selectClientesByApellidoPaterno(apellido);
		if (coleccion == null)
			return null;
		return (ClienteTO[]) coleccion.toArray(new ClienteTO[coleccion.size()]);
	}

	public ClienteTO buscarClientePorId(int id) {
		ClienteTO clienteTO = fabricaDeDAOs.getClienteDAO().findClienteById(id);
		return clienteTO;
	}

	/* CLIENTE DIRECCION */
	public ClienteDireccionTO buscarDireccionesDeCliente(int id) {
		return fabricaDeDAOs.getClienteDireccionDAO()
				.selectClienteDireccionActivoByCliente(id);
	}

	public BitacoraSTO[] selectBitacoraServicio() {
		Collection<BitacoraSTO> col = fabricaDeDAOs.getBitacoraSDAO()
				.selectBitacoraS();
		return ((BitacoraSTO[]) col.toArray(new BitacoraSTO[col.size()]));
	}

	public RfcTO[] selectRfc() {
		Collection<RfcTO> col = fabricaDeDAOs.getRfcDAO().selectRfc();
		return ((RfcTO[]) col.toArray(new RfcTO[col.size()]));
	}

	public RfcTO findRfcByDenominacion(String denominacion) {
		return fabricaDeDAOs.getRfcDAO().findRfcByDenominacion(denominacion);
	}

	public RfcTO findRfcByRegistro(String registro) {
		return fabricaDeDAOs.getRfcDAO().findRfcByRegistro(registro);
	}

	public RfcTO findRfcById(int idrfc) {
		return fabricaDeDAOs.getRfcDAO().findRfcById(idrfc);
	}

	public ClienteRfcTO selectClienteRfcActivoByIdRfc(int idRfc) {
		return fabricaDeDAOs.getClienteRfcDAO().selectClienteRfcActivoByIdRfc(
				idRfc);
	}

	public ClienteRfcTO selectClienteRfcActivoByIdCliente(int idCliente) {
		return fabricaDeDAOs.getClienteRfcDAO()
				.selectClienteRfcActivoByIdCliente(idCliente);
	}

	public ClienteTO[] selectClientesByNombre(String nombre) {
		Collection<ClienteTO> col = fabricaDeDAOs.getClienteDAO()
				.selectClientesByNombre(nombre);
		return ((ClienteTO[]) col.toArray(new ClienteTO[col.size()]));
	}

	public FacturaTO[] findFacturaByMA(int mes, int anio) {
		Collection<FacturaTO> col = fabricaDeDAOs.getFacturaDAO()
				.findFacturaByMA(mes, anio);
		return ((FacturaTO[]) col.toArray(new FacturaTO[col.size()]));
	}

	public DetallePrefacturaTO[] verDetallePrefactura(String rfc) {
		Collection<DetallePrefacturaTO> col = fabricaDeDAOs
				.getDetallePrefacturaDAO().selectDetallePrefacturaByRegistro(
						rfc);
		return ((DetallePrefacturaTO[]) col.toArray(new DetallePrefacturaTO[col
				.size()]));
	}

	public boolean insertDetallePrefactura(
			DetallePrefacturaTO detallePrefacturaTO) {
		return fabricaDeDAOs.getDetallePrefacturaDAO().insertDetallePrefactura(
				detallePrefacturaTO);
	}

	public boolean insertFactura(FacturaTO facturaTO) {
		return fabricaDeDAOs.getFacturaDAO().insertFactura(facturaTO);
	}

	public boolean insertDetalleFactura(DetalleFacturaTO detallefactura) {
		return fabricaDeDAOs.getDetalleFacturaDAO().insertDetalleFactura(
				detallefactura);
	}

	public DetalleFacturaTO[] selectDetalleFactura() {
		Collection<DetalleFacturaTO> col = fabricaDeDAOs.getDetalleFacturaDAO()
				.selectDetalleFactura();
		return ((DetalleFacturaTO[]) col.toArray(new DetalleFacturaTO[col
				.size()]));
	}

	public FacturaTO[] selectFactura() {
		Collection<FacturaTO> col = fabricaDeDAOs.getFacturaDAO()
				.selectFactura();
		return ((FacturaTO[]) col.toArray(new FacturaTO[col.size()]));
	}

	public short borraFactura(int idFactura) {
		return fabricaDeDAOs.getFacturaDAO().deleteFactura(idFactura);
	}

	public short borraDetalleFactura(int idFactura) {
		return fabricaDeDAOs.getDetalleFacturaDAO().deleteDetalleFactura(
				idFactura);
	}

	public short setConsiderado(int id, boolean considerado) {
		return fabricaDeDAOs.getBitacoraSDAO().updateConsiderado(id,
				considerado);
	}

	public short updateFactura(FacturaTO factura) {
		return fabricaDeDAOs.getFacturaDAO().updateFactura(factura);
	}

	public short updateDetalleFactura(DetalleFacturaTO detallefactura) {
		return fabricaDeDAOs.getDetalleFacturaDAO().updateDetalleFactura(
				detallefactura);
	}

	/** puesto salario*** */
	public PuestoSalarioTO[] selectPuestoS() {
		Collection<PuestoSalarioTO> coleccion = fabricaDeDAOs
				.getPuestoSalarioDAO().selectPuestoSalario();
		return (PuestoSalarioTO[]) coleccion
				.toArray(new PuestoSalarioTO[coleccion.size()]);
	}

	public PuestoSalarioTO PuestoSId(short idps) {
		return fabricaDeDAOs.getPuestoSalarioDAO().findPuestoById(idps);
	}

	public boolean addPuestoSalario(PuestoSalarioTO puestosalarioTO) {
		return fabricaDeDAOs.getPuestoSalarioDAO()
				.insertPuesto(puestosalarioTO);
	}

	public short modPuestoSalario(PuestoSalarioTO puestosalarioTO) {
		return fabricaDeDAOs.getPuestoSalarioDAO()
				.updatePuesto(puestosalarioTO);
	}

	public short delPuestoSalario(short idPuesto) {
		return fabricaDeDAOs.getPuestoSalarioDAO().DesActivaPuesto(idPuesto);
	}

	public boolean addDescuento(DescuentoTO desc) {
		return fabricaDeDAOs.getDescuentoDAO().insertDescuento(desc);
	}

	public DescuentoTO[] selectDescuento() {
		Collection<DescuentoTO> coleccion = fabricaDeDAOs.getDescuentoDAO()
				.selectDescuento();
		return (DescuentoTO[]) coleccion.toArray(new DescuentoTO[coleccion
				.size()]);
	}

	public short updateDescuento(DescuentoTO desc) {
		return fabricaDeDAOs.getDescuentoDAO().updateDescuento(desc);
	}

	public boolean insertPercepcion(PercepcionTO per) {
		return fabricaDeDAOs.getPercepcionDAO().insertPercepcion(per);
	}

	public PercepcionTO[] selectPercepcion() {
		Collection<PercepcionTO> coleccion = fabricaDeDAOs.getPercepcionDAO()
				.selectPercepcion();
		return (PercepcionTO[]) coleccion.toArray(new PercepcionTO[coleccion
				.size()]);
	}

	public short updatePercepcion(PercepcionTO per) {
		return fabricaDeDAOs.getPercepcionDAO().updatePercepcion(per);
	}

	public boolean insertComprobantePercepcionDescuento(ComprobantePercepcionDescuentoTO comp) {
		return fabricaDeDAOs.getComprobantePercepcionDescuentoDAO()
				.insertComprobantePercepcionDescuento(comp);
	}

	public ComprobantePercepcionDescuentoTO[] seleccionarCompPercepcionDescuento() {
		Collection<ComprobantePercepcionDescuentoTO> coleccion = fabricaDeDAOs
				.getComprobantePercepcionDescuentoDAO().selectComprobantePercepcionDescuento();
		return (ComprobantePercepcionDescuentoTO[]) coleccion
				.toArray(new ComprobantePercepcionDescuentoTO[coleccion.size()]);
	}

	public short updateCompPD(ComprobantePercepcionDescuentoTO comp) {
		return fabricaDeDAOs.getComprobantePercepcionDescuentoDAO()
				.updateComprobantePercepcionDescuento(comp);
	}

	public boolean insertDescuentoPuesto(DescuentoPuestoTO dp) {
		return fabricaDeDAOs.getDescuentoPuestoDAO().insertDescuentoPuesto(dp);
	}

	public boolean registraDHistorial(DescuentoHistorialTO dh) {
		return fabricaDeDAOs.getDescuentoHistorialDAO()
				.insertDescuentoHistorial(dh);
	}

	public boolean insertarPercepcionP(PercepcionPuestoTO dp) {
		return fabricaDeDAOs.getPercepcionPuestoDAO()
				.insertPercepcionPuesto(dp);
	}

	public boolean registraPerHist(PercepcionHistorialTO dh) {
		return fabricaDeDAOs.getPercepcionHistorialDAO()
				.insertPercepcionHistorial(dh);
	}

	public boolean insertarPerEmp(PercepcionEmpleadoTO dp) {
		return fabricaDeDAOs.getPercepcionEmpleadoDAO()
				.insertPercepcionEmpleado(dp);
	}

	public boolean registraDEmpleado(DescuentoEmpleadoTO dp) {
		return fabricaDeDAOs.getDescuentoEmpleadoDAO().insertDescuentoEmpleado(
				dp);
	}

	public boolean addRango(RangoTO rango) {
		return fabricaDeDAOs.getRangoDAO().insertRango(rango);
	}

	public boolean insertarDEmpleado(DescuentoEmpleadoTO dp) {
		return fabricaDeDAOs.getDescuentoEmpleadoDAO().insertDescuentoEmpleado(
				dp);
	}
	public RangoTO[] selectRango() {
		Collection<RangoTO> coleccion = fabricaDeDAOs.getRangoDAO().selectRango();
		return (RangoTO[]) coleccion.toArray(new RangoTO[coleccion.size()]);
	}
	public boolean insertTipoPercepcionDescuento(TipoPercepcionDescuentoTO tipopd){
		return fabricaDeDAOs.getTipoPercepcionDescuentoDAO().insertTipoPercepcionDescuento(tipopd);
	}
	public TipoPercepcionDescuentoTO [] selectTipoPD()
	{
		Collection<TipoPercepcionDescuentoTO> coleccion = fabricaDeDAOs.getTipoPercepcionDescuentoDAO().selectTipoPercepcionDescuento();
		return (TipoPercepcionDescuentoTO[]) coleccion.toArray(new TipoPercepcionDescuentoTO[coleccion.size()]);
	}
	public DescuentoPuestoTO[] selectDescuentoPuesto(){
		Collection<DescuentoPuestoTO> coleccion= fabricaDeDAOs.getDescuentoPuestoDAO().selectDescuentoPuesto();
		return (DescuentoPuestoTO[]) coleccion.toArray(new DescuentoPuestoTO[coleccion.size()]);
	}
	public PercepcionPuestoTO[] selectperpuesto(){
		Collection<PercepcionPuestoTO> coleccion= fabricaDeDAOs.getPercepcionPuestoDAO().selectPercepcionPuesto();
		return (PercepcionPuestoTO[]) coleccion.toArray(new PercepcionPuestoTO[coleccion.size()]);
	}
	/** ********************* */
	/** *********unidad******** */
	public boolean registrarUnidad(UnidadTO unidad) {
		return fabricaDeDAOs.getUnidadDAO().insertUnidad(unidad);
	}

	public short modificarUnidad(UnidadTO unidad) {
		return fabricaDeDAOs.getUnidadDAO().updateUnidad(unidad);
	}

	public short eliminarUnidad(int id) {
		return fabricaDeDAOs.getUnidadDAO().activaDesactivaUnidad(id, false);
	}

	public UnidadTO[] obtenerUnidades() {
		Collection<UnidadTO> coleccion = fabricaDeDAOs.getUnidadDAO()
				.selectUnidad();
		return ((UnidadTO[]) coleccion.toArray(new UnidadTO[coleccion.size()]));
	}
	
	public UnidadTO[] getDatosUnidad(String placas) {
		Collection<UnidadTO> coleccion = fabricaDeDAOs.getUnidadDAO()
				.selectUnidadByPlacas(placas);
		return ((UnidadTO[]) coleccion.toArray(new UnidadTO[coleccion.size()]));
	}

	/** ********************** */
	/** ******servicios*********** */
	public int asignarServicio(BitacoraServicioTO bitacorato) {
		return fabricaDeDAOs.getBitacoraServicioDAO().insertBitacoraServicio(
				bitacorato);
	}

	public BitacoraServicioTO[] buscarServicios(Date inicioFecha,
			Date finFecha, Time inicioHora, Time finHora, boolean factura) {
		Collection<BitacoraServicioTO> datos = fabricaDeDAOs
				.getBitacoraServicioDAO().selectByRangoFechaHoraFactura(
						inicioFecha, finFecha, inicioHora, finHora, factura);
		return ((BitacoraServicioTO[]) datos
				.toArray(new BitacoraServicioTO[datos.size()]));
	}

	public short cancelarServicio(BitacoraServicioTO bitacorato) {
		return fabricaDeDAOs.getBitacoraServicioDAO().updateBitacoraServicio(
				bitacorato);
	}

	/** ********************chofer********************* */
	public boolean agregarChofer(ChoferTO chofer) {
		return fabricaDeDAOs.getChoferDAO().insertChofer(chofer);
	}

	public short modificarChofer(ChoferTO chofer) {
		return fabricaDeDAOs.getChoferDAO().updateChofer(chofer);
	}

	public short eliminarChofer(int id) {
		return fabricaDeDAOs.getChoferDAO().activaDesactivaChofer(id, false);
	}

	public ChoferTO[] obtenerChoferes () {
		Collection<ChoferTO> coleccion = fabricaDeDAOs.getChoferDAO()
				.selectChofer();
		return (ChoferTO[]) coleccion.toArray(new ChoferTO[coleccion.size()]);
	}
	
	public ChoferTO[] getDatosChofer(String nombre, String apellidoPaterno) {
		Collection<ChoferTO> coleccion = fabricaDeDAOs.getChoferDAO()
				.selectChoferByNombreApellidoPaterno(nombre, apellidoPaterno);
		return (ChoferTO[]) coleccion.toArray(new ChoferTO[coleccion.size()]);
	}

	/** ********************base********************* */
	public BaseTO[] seleccionarBases() {
		Collection<BaseTO> coleccion = fabricaDeDAOs.getBaseDAO().selectBase();
	
		return (BaseTO[]) coleccion.toArray(new BaseTO[coleccion.size()]);
	}
	
	public boolean agregarBase(BaseTO base) {
		return fabricaDeDAOs.getBaseDAO().insertBase(base);
	}

	public short modificarBase(BaseTO base) {
		return fabricaDeDAOs.getBaseDAO().updateBase(base);
	}

	public short eliminarBase(int id) {
		return fabricaDeDAOs.getBaseDAO().deleteBase(id);
	}

	public BaseTO getDatosBase(short id) {
		return fabricaDeDAOs.getBaseDAO().selectBaseByTipoBase(id);
	}

	/** ********************economico********************* */
	public boolean agregarEconomico(EconomicoTO economico) {
		return fabricaDeDAOs.getEconomicoDAO().insertEconomico(economico);
	}

	public short modificarEconomico(EconomicoTO economico) {
		return fabricaDeDAOs.getEconomicoDAO().updateEconomico(economico);
	}

	public short eliminarEconomico(int id) {
		return fabricaDeDAOs.getEconomicoDAO().DesActivaEconomico(id);
	}

	public EconomicoTO[] obtenerEconomicos() {
		Collection<EconomicoTO> coleccion = fabricaDeDAOs.getEconomicoDAO()
				.selectEconomico();
		return (EconomicoTO[]) coleccion.toArray(new EconomicoTO[coleccion
				.size()]);
	}
	
	public EconomicoTO[] getDatosEconomico() {
		Collection<EconomicoTO> coleccion = fabricaDeDAOs.getEconomicoDAO()
				.selectEconomico();
		return (EconomicoTO[]) coleccion.toArray(new EconomicoTO[coleccion
				.size()]);
	}

	/** ********************castigo********************* */
	public boolean agregarCastigo(BitacoraCastigoChoferTO castigo) {
		return fabricaDeDAOs.getBitacoraCastigoChoferDAO()
				.insertBitacoraCastigoChofer(castigo);
	}

	public short modificarCastigo(BitacoraCastigoChoferTO castigo) {
		return fabricaDeDAOs.getBitacoraCastigoChoferDAO()
				.updateBitacoraCastigoChofer(castigo);
	}

	public BitacoraCastigoChoferTO getDatosCastigo(Date inicio, Date fin, int id) {
		return fabricaDeDAOs.getBitacoraCastigoChoferDAO()
				.selectByRangoFechaChofer(inicio, fin, id);
	}

	/** ********************choferunidad********************* */
	public int asignarChoferUnidad(BitacoraChoferUnidadTO choferunidad) {
		return fabricaDeDAOs.getBitacoraChoferUnidadDAO()
				.insertBitacoraChoferUnidad(choferunidad);
	}

	public short modificarChoferUnidad(BitacoraChoferUnidadTO choferunidad) {
		return fabricaDeDAOs.getBitacoraChoferUnidadDAO()
				.updateBitacoraChoferUnidad(choferunidad);
	}

	public BitacoraChoferUnidadTO[] getDatosChoferUnidad(Date inicio, Date fin) {
		Collection<BitacoraChoferUnidadTO> coleccion = fabricaDeDAOs
				.getBitacoraChoferUnidadDAO().selectByRangoFecha(inicio, fin);
		return (BitacoraChoferUnidadTO[]) coleccion
				.toArray(new BitacoraChoferUnidadTO[coleccion.size()]);

	}

	/** *************************** */
	/* USUARIO */
	// Lo usa el negocio: Login();
	public UsuarioTO buscarUsuarioPorNombre(String nombreUsuario) {
		UsuarioTO usuarioTO = fabricaDeDAOs.getUsuarioDAO()
				.findUsuarioByNombre(nombreUsuario);
		return usuarioTO;
	}

	public FormaPagoTO[] seleccionarFormasPago() {
		Collection<FormaPagoTO> coleccion = fabricaDeDAOs.getFormaPagoDAO()
				.selectFormaPago();
		return (FormaPagoTO[]) coleccion.toArray(new FormaPagoTO[coleccion
				.size()]);
	}

	public TipoServicioTO[] seleccionarTiposServicio() {
		Collection<TipoServicioTO> coleccion = fabricaDeDAOs
				.getTipoServicioDAO().selectTipoServicio();
		return (TipoServicioTO[]) coleccion
				.toArray(new TipoServicioTO[coleccion.size()]);
	}

	/* SERVICIOS */
	
	public int agregarServicio(BitacoraServicioTO bitacora) {
		return fabricaDeDAOs.getBitacoraServicioDAO().insertBitacoraServicio(
				bitacora);
	}
	
	public BitacoraServicioTO buscarBitacoraPorId(int id) {
		return fabricaDeDAOs.getBitacoraServicioDAO().findBitacoraServicioById(id);
	}

	public short actualizarBitacoraServicios(BitacoraServicioTO bitacoraServicioTO){
		return fabricaDeDAOs.getBitacoraServicioDAO().updateBitacoraServicio(bitacoraServicioTO);
	}
	
	public BitacoraServicioTO obtenerBitacoraServiciosPorFechaTelefonista(
			PeticionBitacoraServicioTO to) {
		return fabricaDeDAOs.getBitacoraServicioDAO()
				.selectByRangoFechaHoraTelefonista(
						FechaHoraTO.getFecha(to.getFechaInicio()),
						FechaHoraTO.getFecha(to.getFechaTermino()),
						FechaHoraTO.getHora(to.getHoraInicio()),
						FechaHoraTO.getHora(to.getHoraTermino()),
						to.getIdUsuario());
	}
	
	public BitacoraServicioTO[] obtenerBitacoraServiciosPorDia(
			java.util.Date dia) {
		Collection<BitacoraServicioTO> coleccion = fabricaDeDAOs.getBitacoraServicioDAO()
		.selectBitacoraServicioByDia(
				FechaHoraTO.getFecha(dia));
		
		if(coleccion==null)
			return null;
		
		if(coleccion.size()==0)
			return null;
		
		return (BitacoraServicioTO[]) coleccion
		.toArray(new BitacoraServicioTO[coleccion.size()]);
	}

	/** ******************************************** */
	/* Tipo Empleado */

	public TipoEmpleadoTO[] seleccionarTiposdeEmpleado() {
		Collection<TipoEmpleadoTO> coleccion = fabricaDeDAOs
				.getTipoEmpleadoDAO().selectTipoEmpleado();
		return (TipoEmpleadoTO[]) coleccion
				.toArray(new TipoEmpleadoTO[coleccion.size()]);
	}

	/** ******************************************** */
	/* PUESTO */

	public PuestoTO[] seleccionarPuestosActivos() {
		Collection<PuestoTO> coleccion = fabricaDeDAOs.getPuestoDAO()
				.selectPuestoActivo();
		return (PuestoTO[]) coleccion.toArray(new PuestoTO[coleccion.size()]);
	}

	public PuestoTO seleccionarPuestoActivoporTipoEmpleado(short idTipoEmpleado) {
		return fabricaDeDAOs.getPuestoDAO().selectPuestoActivoByTipoEmpleado(
				idTipoEmpleado);
	}

	public PuestoTO encontrarPuestoporIdPuesto(short idPuesto) {
		return fabricaDeDAOs.getPuestoDAO().findPuestoById(idPuesto);
	}

	public boolean agregarPuesto(PuestoTO puestoTO) {
		return fabricaDeDAOs.getPuestoDAO().insertPuesto(puestoTO);
	}

	public PuestoTO obtenerPuestoporNombreIdTipoEmp(PuestoTO puestoTO) {
		return fabricaDeDAOs.getPuestoDAO().findPuestoByNombreTipoEmpleado(
				puestoTO.getNombre(),
				puestoTO.getTipoEmpleadoTO().getIdTipoEmpleado());
	}

	public short modificarPuesto(PuestoTO puestoTO) {
		return fabricaDeDAOs.getPuestoDAO().updatePuesto(puestoTO);
	}

	public short bajaPuesto(short idPuesto) {
		return fabricaDeDAOs.getPuestoDAO().DesActivaPuesto(idPuesto);
	}
	public DescuentoPuestoTO[] selectDescp(){
		Collection<DescuentoPuestoTO> coleccion= fabricaDeDAOs.getDescuentoPuestoDAO().selectDescuentoPuesto();
		return (DescuentoPuestoTO[]) coleccion.toArray(new DescuentoPuestoTO[coleccion.size()]);
	}
	/** ******************************************** */
	/* TURNO */
	public TurnoTO encontrarTurnoPorNombre(String nombre) {
		TurnoTO turnoTO = null;
		turnoTO = fabricaDeDAOs.getTurnoDAO().findTurnoByNombre(nombre);
		return turnoTO;
	}

	public boolean agregarTurno(TurnoTO turnoTO) {
		return fabricaDeDAOs.getTurnoDAO().insertTurno(turnoTO);
	}

	public TurnoTO[] buscarTurnos() {
		TurnoTO[] turnoTO = null;
		Collection<TurnoTO> coleccion = fabricaDeDAOs.getTurnoDAO()
				.selectTurno();
		if (coleccion == null) {
			turnoTO = new TurnoTO[1];
			turnoTO[0] = new TurnoTO();
			turnoTO[0].setTipoError(TransferObject.INFO);
		}

		else
			turnoTO = (TurnoTO[]) coleccion.toArray(new TurnoTO[coleccion
					.size()]);
		return turnoTO;
	}

	public TurnoTO[] encontrarTurnoPorRangoInicio(TurnoTO[] rangoTO) {
		TurnoTO[] turnoTO = null;
		Collection<TurnoTO> coleccion = fabricaDeDAOs.getTurnoDAO()
				.selectTurnoByRangoHorario(
						FechaHoraTO.getHora(rangoTO[0].getHoraInicio()),
						FechaHoraTO.getHora(rangoTO[1].getHoraInicio()));
		if (coleccion == null) {
			turnoTO = new TurnoTO[1];
			turnoTO[0] = new TurnoTO();
			turnoTO[0].setTipoError(TransferObject.INFO);
		}

		else
			turnoTO = (TurnoTO[]) coleccion.toArray(new TurnoTO[coleccion
					.size()]);

		return turnoTO;
	}

	public TurnoTO[] encontrarTurnoPorRangoDia(TurnoTO[] rangoTO) {
		TurnoTO[] turnoTO = null;
		Collection<TurnoTO> coleccion = fabricaDeDAOs.getTurnoDAO()
				.selectTurnoByRangoDias(rangoTO[0].getDiasSemana(),
						rangoTO[1].getDiasSemana());
		if (coleccion == null) {
			turnoTO = new TurnoTO[1];
			turnoTO[0] = new TurnoTO();
			turnoTO[0].setTipoError(TransferObject.INFO);
		} else
			turnoTO = (TurnoTO[]) coleccion.toArray(new TurnoTO[coleccion
					.size()]);
		return turnoTO;
	}

	public TurnoTO[] encontrarTurnoPorRangoDuracion(TurnoTO[] rangoTO) {
		TurnoTO[] turnoTO = null;
		Collection<TurnoTO> coleccion = fabricaDeDAOs.getTurnoDAO()
				.selectTurnoByRangoDuracion(
						FechaHoraTO.getHora(rangoTO[0].getDuracion()),
						FechaHoraTO.getHora(rangoTO[1].getDuracion()));
		if (coleccion == null) {
			turnoTO = new TurnoTO[1];
			turnoTO[0] = new TurnoTO();
			turnoTO[0].setTipoError(TransferObject.INFO);
		}

		else
			turnoTO = (TurnoTO[]) coleccion.toArray(new TurnoTO[coleccion
					.size()]);
		return turnoTO;
	}

	public short bajaTurno(int idTurno) {
		return fabricaDeDAOs.getTurnoDAO().activarDesactivarTurno(idTurno,
				false);
	}

	public short modificarTurno(TurnoTO turnoTO) {
		return fabricaDeDAOs.getTurnoDAO().updateTurno(turnoTO);
	}

	/** ******************************************** */
	/* EMPLEADO */
	public EmpleadoTO[] buscarEmpleadosActivos() {
		EmpleadoTO[] empleadoTO = null;
		Collection<EmpleadoTO> coleccion = fabricaDeDAOs.getEmpleadoDAO()
				.selectEmpleadoActivo();
		if (coleccion == null) {
			empleadoTO = new EmpleadoTO[1];
			empleadoTO[0] = new EmpleadoTO();
			empleadoTO[0].setTipoError(TransferObject.INFO);
		} else
			empleadoTO = (EmpleadoTO[]) coleccion
					.toArray(new EmpleadoTO[coleccion.size()]);
		return empleadoTO;
	}

	public ColoniaTO buscarColoniasPorMunicipio(int idMunicipio) {
		ColoniaTO coloniaTO = null;
		coloniaTO = fabricaDeDAOs.getColoniaDAO().selectColoniaByMunicipio(
				idMunicipio);
		if (coloniaTO == null) {
			coloniaTO = new ColoniaTO();
			coloniaTO.setTipoError(TransferObject.INFO);
		}
		return coloniaTO;
	}

	public ColoniaCalleTO buscarCallesPorColonia(int idColonia) {
		ColoniaCalleTO coloniaCalleTO = null;
		coloniaCalleTO = fabricaDeDAOs.getColoniaCalleDAO()
				.selectColoniaCalleByColonia(idColonia);
		if (coloniaCalleTO == null) {
			coloniaCalleTO = new ColoniaCalleTO();
			coloniaCalleTO.setTipoError(TransferObject.INFO);
		}
		return coloniaCalleTO;
	}

	public EmpleadoTO[] jefeDistintoActivo() {
		EmpleadoTO[] arrEmpleadoTO = null;
		Collection<EmpleadoTO> coleccion = fabricaDeDAOs.getResponsableDAO()
				.selectJefeDistintoActivo();
		if (coleccion == null) {
			arrEmpleadoTO = new EmpleadoTO[1];
			arrEmpleadoTO[0] = new EmpleadoTO();
			arrEmpleadoTO[0].setTipoError(TransferObject.INFO);
		} else {
			arrEmpleadoTO = (EmpleadoTO[]) coleccion
					.toArray(new EmpleadoTO[coleccion.size()]);
		}
		return arrEmpleadoTO;
	}

	public EmpleadoTO encontrarEmpleadoActivoPorCURP(String curp) {
		EmpleadoTO empleadoTO = null;
		empleadoTO = fabricaDeDAOs.getEmpleadoDAO().findEmpleadoByCurp(curp);
		if (empleadoTO == null) {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
		}
		return empleadoTO;
	}

	public PersonaTO encontrarPersonaPorCURP(String curp) {
		PersonaTO personaTO = null;
		Collection<PersonaTO> coleccion = fabricaDeDAOs.getPersonaDAO()
				.selectPersonasByCURP(curp);
		if (coleccion == null) {
			personaTO = new PersonaTO();
			personaTO.setTipoError(TransferObject.INFO);
		} else {
			PersonaTO[] arrPersonaTO = (PersonaTO[]) coleccion
					.toArray(new PersonaTO[coleccion.size()]);
			personaTO = arrPersonaTO[0];
		}

		return personaTO;
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorPaterno(String paterno) {
		EmpleadoTO[] arrEmpleadoTO = null;
		Collection<EmpleadoTO> coleccion = fabricaDeDAOs.getEmpleadoDAO()
				.selectEmpleadoByPaternoActivo(paterno);
		if (coleccion == null) {
			arrEmpleadoTO = new EmpleadoTO[1];
			arrEmpleadoTO[0] = new EmpleadoTO();
			arrEmpleadoTO[0].setTipoError(TransferObject.INFO);
		} else {
			arrEmpleadoTO = (EmpleadoTO[]) coleccion
					.toArray(new EmpleadoTO[coleccion.size()]);
		}
		return arrEmpleadoTO;
	}

	public EmpleadoTO[] encontrarEmpleadosActivosPorNombrePaterno(
			PersonaTO personaTO) {
		EmpleadoTO[] arrEmpleadoTO = null;
		Collection<EmpleadoTO> coleccion = fabricaDeDAOs.getEmpleadoDAO()
				.selectEmpleadoByNombrePaternoActivo(personaTO.getNombre(),
						personaTO.getApellidoPaterno());
		if (coleccion == null) {
			arrEmpleadoTO = new EmpleadoTO[1];
			arrEmpleadoTO[0] = new EmpleadoTO();
			arrEmpleadoTO[0].setTipoError(TransferObject.INFO);

		} else {
			arrEmpleadoTO = (EmpleadoTO[]) coleccion
					.toArray(new EmpleadoTO[coleccion.size()]);
		}
		return arrEmpleadoTO;
	}

	public EmpleadoTO encontrarEmpleadoActivoPorNss(String nss) {
		EmpleadoTO empleadoTO = null;
		empleadoTO = fabricaDeDAOs.getEmpleadoDAO().findEmpleadoByNss(nss);
		if (empleadoTO == null) {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
		}
		return empleadoTO;
	}

	public EmpleadoTO encontrarEmpleadosActivosPorPuesto(short idPuesto) {
		EmpleadoTO empleadoTO = null;
		empleadoTO = fabricaDeDAOs.getEmpleadoDAO()
				.selectEmpleadoActivoByPuesto(idPuesto);
		if (empleadoTO == null) {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
		}
		return empleadoTO;
	}

	public ResponsableTO encontrarEmpleadosActivosPorJefe(int idJefe) {
		ResponsableTO responsableTO = null;
		responsableTO = fabricaDeDAOs.getResponsableDAO()
				.selectResponsableActivoByJefe(idJefe);
		if (responsableTO == null) {
			responsableTO = new ResponsableTO();
			responsableTO.setTipoError(TransferObject.INFO);
		}
		return responsableTO;
	}

	public ResponsableTO encontrarJefeActivoPorSubordinado(int idSubordinado) {
		ResponsableTO responsableTO = null;
		responsableTO = fabricaDeDAOs.getResponsableDAO()
				.selectResponsableActivoBySubordinado(idSubordinado);
		if (responsableTO == null) {
			responsableTO = new ResponsableTO();
			responsableTO.setTipoError(TransferObject.INFO);
		}
		return responsableTO;
	}

	public short desactivaResponsable(int idResponsable) {
		return fabricaDeDAOs.getResponsableDAO().activaDesactivaResponsable(
				idResponsable, false);
	}

	public boolean agregarBitacoraResponsable(
			BitacoraResponsableTO bitacoraResponsableTO) {
		bitacoraResponsableTO.setFecha(new java.util.Date());
		return fabricaDeDAOs.getBitacoraResponsableDAO()
				.insertBitacoraResponsable(bitacoraResponsableTO);

	}

	public boolean agregarBitacoraEmpleado(BitacoraEmpleadoTO bitacoraEmpleadoTO) {
		bitacoraEmpleadoTO.setFecha(new java.util.Date());
		return fabricaDeDAOs.getBitacoraEmpleadoDAO().insertBitacoraEmpleado(
				bitacoraEmpleadoTO);

	}

	public boolean agregarEmpleado(EmpleadoTO empleadoTO) {
		return fabricaDeDAOs.getEmpleadoDAO().insertEmpleado(empleadoTO);
	}

	public short desactivaEmpleado(int idEmpleado) {
		return fabricaDeDAOs.getEmpleadoDAO().activaDesactivaEmpleado(
				idEmpleado, false);
	}

	public boolean agregarPersona(PersonaTO personaTO) {
		return fabricaDeDAOs.getPersonaDAO().insertPersona(personaTO);
	}

	public short modificarPersona(PersonaTO personaTO) {
		return fabricaDeDAOs.getPersonaDAO().updatePersona(personaTO);
	}

	public boolean agregarResponsable(ResponsableTO responsableTO) {
		return fabricaDeDAOs.getResponsableDAO().insertResponsable(
				responsableTO);
	}

	public DireccionTO encontrarDireccionPorIdDireccion(int idDireccion) {
		DireccionTO respTO = null;
		respTO = fabricaDeDAOs.getDireccionDAO().findDireccionById(idDireccion);
		if (respTO == null) {
			respTO = new DireccionTO();
			respTO.setTipoError(TransferObject.INFO);
		}
		return respTO;
	}

	public DireccionTO encontrarDireccionPorNumeroInteriorColoniaCalle(
			DireccionTO direccionTO) {
		DireccionTO respTO = null;
		respTO = fabricaDeDAOs.getDireccionDAO()
				.findDireccionByNumeroIntColoniaCalle(direccionTO.getNumero(),
						direccionTO.getInterior(),
						direccionTO.getColoniaCalleTO().getIdColoniaCalle());
		if (respTO == null) {
			respTO = new DireccionTO();
			respTO.setTipoError(TransferObject.INFO);
		}
		return respTO;
	}

	public short modificarEmpleado(EmpleadoTO empleadoTO) {
		return fabricaDeDAOs.getEmpleadoDAO().updateEmpleado(empleadoTO);
	}

	public ResponsableTO encontrarResponsableActivoPorJefeySubordinado(
			EmpleadoTO[] arrEmpleado) {
		ResponsableTO responsableTO = null;
		responsableTO = fabricaDeDAOs.getResponsableDAO()
				.findResponsableByJefeSubordinado(
						arrEmpleado[0].getIdEmpleado(),
						arrEmpleado[1].getIdEmpleado());
		if (responsableTO == null) {
			responsableTO = new ResponsableTO();
			responsableTO.setTipoError(TransferObject.INFO);
		}
		return responsableTO;
	}

	/** ******************************************** */
	/* Usuario */

	public UsuarioTO[] encontrarUsuariosPorActivo(boolean activo) {
		UsuarioTO[] arrUsuarioTO = null;
		Collection<UsuarioTO> coleccion = fabricaDeDAOs.getUsuarioDAO()
				.selectUsuariosByActivo(activo);
		if (coleccion == null) {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.INFO);

		} else {
			arrUsuarioTO = (UsuarioTO[]) coleccion
					.toArray(new UsuarioTO[coleccion.size()]);
		}
		return arrUsuarioTO;
	}

	public UsuarioTO[] obtenerUsuarios() {
		UsuarioTO[] arrUsuarioTO = null;
		Collection<UsuarioTO> coleccion = fabricaDeDAOs.getUsuarioDAO()
				.selectUsuarios();
		if (coleccion == null) {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.INFO);

		} else {
			arrUsuarioTO = (UsuarioTO[]) coleccion
					.toArray(new UsuarioTO[coleccion.size()]);
		}
		return arrUsuarioTO;
	}

	public EmpleadoTO encontrarEmpleadoPorID(int idEmpleado) {
		EmpleadoTO empleadoTO = null;
		empleadoTO = fabricaDeDAOs.getEmpleadoDAO()
				.findEmpleadoById(idEmpleado);
		if (empleadoTO == null) {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
		}
		return empleadoTO;
	}

	public GrupoUsuarioTO[] ObtenerGruposDeUsuario() {
		GrupoUsuarioTO[] arrGrupoUsuarioTO = null;
		Collection<GrupoUsuarioTO> coleccion = fabricaDeDAOs
				.getGrupoUsuarioDAO().selectGrupoUsuario();
		if (coleccion == null) {
			arrGrupoUsuarioTO = new GrupoUsuarioTO[1];
			arrGrupoUsuarioTO[0] = new GrupoUsuarioTO();
			arrGrupoUsuarioTO[0].setTipoError(TransferObject.INFO);

		} else {
			arrGrupoUsuarioTO = (GrupoUsuarioTO[]) coleccion
					.toArray(new GrupoUsuarioTO[coleccion.size()]);
		}
		return arrGrupoUsuarioTO;
	}

	public UsuarioTO[] encontrarUsuariosPorGrupo(short idGrupoUsuario) {
		UsuarioTO[] arrUsuarioTO = null;
		Collection<UsuarioTO> coleccion = fabricaDeDAOs.getUsuarioDAO()
				.selectUsuariosByGrupo(idGrupoUsuario);
		if (coleccion == null) {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.INFO);

		} else {
			arrUsuarioTO = (UsuarioTO[]) coleccion
					.toArray(new UsuarioTO[coleccion.size()]);
		}
		return arrUsuarioTO;
	}

	public UsuarioTO encontrarUsuarioPorNombre(String nombreUsuario) {
		UsuarioTO usuarioTO = null;
		usuarioTO = fabricaDeDAOs.getUsuarioDAO().findUsuarioByNombre(
				nombreUsuario);
		if (usuarioTO == null) {
			usuarioTO = new UsuarioTO();
			usuarioTO.setTipoError(TransferObject.INFO);
		}
		return usuarioTO;
	}

	public UsuarioTO encontrarUsuarioPorIdEmpleado(int idEmpleado) {
		UsuarioTO usuarioTO = null;
		usuarioTO = fabricaDeDAOs.getUsuarioDAO().findUsuarioByEmpleado(
				idEmpleado);
		if (usuarioTO == null) {
			usuarioTO = new UsuarioTO();
			usuarioTO.setTipoError(TransferObject.INFO);
		}
		return usuarioTO;
	}

	public EmpleadoTO encontrarEmpleadoPorNssActivoEInactivo(String nss) {
		EmpleadoTO empleadoTO = null;
		empleadoTO = fabricaDeDAOs.getEmpleadoDAO()
				.findEmpleadoByNssActivoEInactivo(nss);
		if (empleadoTO == null) {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
		}
		return empleadoTO;
	}

	public int agregarUsuario(UsuarioTO usuarioTO) {
		return fabricaDeDAOs.getUsuarioDAO().insertUsuario(usuarioTO);
	}

	public short modificarUsuario(UsuarioTO usuarioTO) {
		return fabricaDeDAOs.getUsuarioDAO().updateUsuario(usuarioTO);
	}

	/** ******************************************** */
	/* DiaFestivo */
	public DiaFestivoTO[] encontrarDiasFestivosActivos() {
		DiaFestivoTO[] diaFestivoTO = null;
		Collection<DiaFestivoTO> coleccion = fabricaDeDAOs.getDiaFestivoDAO()
				.selectDiasFestivosActivos();
		if (coleccion == null) {
			diaFestivoTO = new DiaFestivoTO[1];
			diaFestivoTO[0] = new DiaFestivoTO();
			diaFestivoTO[0].setTipoError(TransferObject.INFO);
		} else
			diaFestivoTO = (DiaFestivoTO[]) coleccion
					.toArray(new DiaFestivoTO[coleccion.size()]);
		return diaFestivoTO;
	}

	public DiaFestivoTO encontrarDiaFestivoPorIdActivo(int idDiaFestivo) {
		DiaFestivoTO diaFestivoTO = null;
		diaFestivoTO = fabricaDeDAOs.getDiaFestivoDAO().findDiaFestivoById(
				idDiaFestivo);
		if (diaFestivoTO == null) {
			diaFestivoTO = new DiaFestivoTO();
			diaFestivoTO.setTipoError(TransferObject.INFO);
		}
		return diaFestivoTO;
	}

	public short modificarDiaFestivo(DiaFestivoTO diaFestivoTO) {
		return fabricaDeDAOs.getDiaFestivoDAO().updateDiaFestivo(diaFestivoTO);
	}

	public int agregarDiaFestivo(DiaFestivoTO diaFestivoTO) {
		return fabricaDeDAOs.getDiaFestivoDAO().insertDiaFestivo(diaFestivoTO);
	}

	public DiaFestivoTO[] encontrarDiasFestivosPorMesActivos(short mes) {
		DiaFestivoTO[] diaFestivoTO = null;
		Collection<DiaFestivoTO> coleccion = fabricaDeDAOs.getDiaFestivoDAO()
				.selectDiasFestivosByMes(mes);
		if (coleccion == null) {
			diaFestivoTO = new DiaFestivoTO[1];
			diaFestivoTO[0] = new DiaFestivoTO();
			diaFestivoTO[0].setTipoError(TransferObject.INFO);
		} else
			diaFestivoTO = (DiaFestivoTO[]) coleccion
					.toArray(new DiaFestivoTO[coleccion.size()]);
		return diaFestivoTO;
	}

	public DiaFestivoTO encontrarDiaFestivoPorMesDiaActivo(DiaFestivoTO diaFesTO) {
		DiaFestivoTO diaFestivoTO = null;
		diaFestivoTO = fabricaDeDAOs.getDiaFestivoDAO()
				.findDiaFestivoByMesDiaActivo(diaFesTO.getMes(),
						diaFesTO.getDia());
		if (diaFestivoTO == null) {
			diaFestivoTO = new DiaFestivoTO();
			diaFestivoTO.setTipoError(TransferObject.INFO);
		}
		return diaFestivoTO;
	}

	/** ******************************************** */
	/* Reportes */

	public FormaPagoTO[] encontrarFormasDePago() {
		FormaPagoTO[] arrFormaPagoTO = null;
		Collection<FormaPagoTO> coleccion = fabricaDeDAOs.getFormaPagoDAO()
				.selectFormaPago();
		if (coleccion == null) {
			arrFormaPagoTO = new FormaPagoTO[1];
			arrFormaPagoTO[0] = new FormaPagoTO();
			arrFormaPagoTO[0].setTipoError(TransferObject.INFO);
		} else
			arrFormaPagoTO = (FormaPagoTO[]) coleccion
					.toArray(new FormaPagoTO[coleccion.size()]);
		return arrFormaPagoTO;
	}

	public BitacoraServicioTO encontrarServiciosPorFormaPago(ReporteTO reporte) {
		BitacoraServicioTO bitacoraServicioTO = null;
		bitacoraServicioTO = fabricaDeDAOs.getBitacoraServicioDAO()
				.selectByRangoFechaHoraFormaPago(
						FechaHoraTO.getFecha(reporte.getFechaInicio()),
						FechaHoraTO.getFecha(reporte.getFechaFin()),
						FechaHoraTO.getHora(reporte.getHoraInicio()),
						FechaHoraTO.getHora(reporte.getHoraFin()),
						(short) reporte.getIdReferencia());

		if (bitacoraServicioTO == null) {
			bitacoraServicioTO = new BitacoraServicioTO();
			bitacoraServicioTO.setTipoError(TransferObject.INFO);
		}
		return bitacoraServicioTO;
	}

	public BitacoraServicioTO encontrarServiciosPorOperadora(ReporteTO reporte) {
		BitacoraServicioTO bitacoraServicioTO = null;
		bitacoraServicioTO = fabricaDeDAOs.getBitacoraServicioDAO()
				.selectByRangoFechaHoraOperadora(
						FechaHoraTO.getFecha(reporte.getFechaInicio()),
						FechaHoraTO.getFecha(reporte.getFechaFin()),
						FechaHoraTO.getHora(reporte.getHoraInicio()),
						FechaHoraTO.getHora(reporte.getHoraFin()),
						reporte.getIdReferencia());

		if (bitacoraServicioTO == null) {
			bitacoraServicioTO = new BitacoraServicioTO();
			bitacoraServicioTO.setTipoError(TransferObject.INFO);
		}
		return bitacoraServicioTO;
	}

	public BitacoraServicioTO encontrarServiciosPorTelefinista(ReporteTO reporte) {
		BitacoraServicioTO bitacoraServicioTO = null;
		bitacoraServicioTO = fabricaDeDAOs.getBitacoraServicioDAO()
				.selectByRangoFechaHoraTelefonista(
						FechaHoraTO.getFecha(reporte.getFechaInicio()),
						FechaHoraTO.getFecha(reporte.getFechaFin()),
						FechaHoraTO.getHora(reporte.getHoraInicio()),
						FechaHoraTO.getHora(reporte.getHoraFin()),
						reporte.getIdReferencia());

		if (bitacoraServicioTO == null) {
			bitacoraServicioTO = new BitacoraServicioTO();
			bitacoraServicioTO.setTipoError(TransferObject.INFO);
		}
		return bitacoraServicioTO;
	}

	public BitacoraServicioTO[] encontrarServiciosPorRangoUnidadFechaHora(
			ReporteTO reporte) {
		BitacoraServicioTO[] bitacoraServicioTO = null;
		Collection<BitacoraServicioTO> coleccion = fabricaDeDAOs
				.getBitacoraServicioDAO().selectByRangoFechaHoraRangoUnidad(
						FechaHoraTO.getFecha(reporte.getFechaInicio()),
						FechaHoraTO.getFecha(reporte.getFechaFin()),
						FechaHoraTO.getHora(reporte.getHoraInicio()),
						FechaHoraTO.getHora(reporte.getHoraFin()),
						reporte.getIdReferencia(), reporte.getIdReferencia());
		if (coleccion == null) {
			bitacoraServicioTO = new BitacoraServicioTO[1];
			bitacoraServicioTO[0] = new BitacoraServicioTO();
			bitacoraServicioTO[0].setTipoError(TransferObject.INFO);
		} else
			bitacoraServicioTO = (BitacoraServicioTO[]) coleccion
					.toArray(new BitacoraServicioTO[coleccion.size()]);
		return bitacoraServicioTO;
	}
	
	public TipoServicioTO[] encontrarTiposServicio() {
		TipoServicioTO[] arrTipoServicioTO = null;
		Collection<TipoServicioTO> coleccion = fabricaDeDAOs.getTipoServicioDAO().selectTipoServicio();
		if (coleccion == null) {
			arrTipoServicioTO = new TipoServicioTO[1];
			arrTipoServicioTO[0] = new TipoServicioTO();
			arrTipoServicioTO[0].setTipoError(TransferObject.INFO);
		} else
			arrTipoServicioTO = (TipoServicioTO[]) coleccion
					.toArray(new TipoServicioTO[coleccion.size()]);
		return arrTipoServicioTO;
	}
	
	public int obtenerNumeroUnidades() {
		UnidadTO[] arrUnidadTO = null;
		Collection<UnidadTO> coleccion = fabricaDeDAOs.getUnidadDAO().selectUnidad();
		if (coleccion == null) {
			return -1;
		} else
			arrUnidadTO = (UnidadTO[]) coleccion
					.toArray(new UnidadTO[coleccion.size()]);
		return arrUnidadTO.length;
	}

	public BitacoraServicioTO encontrarServiciosPorTipoServicio(ReporteTO reporte) {
		BitacoraServicioTO bitacoraServicioTO = null;
		bitacoraServicioTO = fabricaDeDAOs.getBitacoraServicioDAO()
				.selectByRangoFechaHoraRangoUnidadStatusTipoServicio(FechaHoraTO.getFecha(reporte.getFechaInicio()),
						FechaHoraTO.getFecha(reporte.getFechaFin()),
						FechaHoraTO.getHora(reporte.getHoraInicio()),
						FechaHoraTO.getHora(reporte.getHoraFin()),reporte.getUnidadInicio(),reporte.getUnidadFin(),(short)3,
						reporte.getIdReferencia());

		if (bitacoraServicioTO == null) {
			bitacoraServicioTO = new BitacoraServicioTO();
			bitacoraServicioTO.setTipoError(TransferObject.INFO);
		}
		return bitacoraServicioTO;
	}
	
	public java.util.Date obtenerFechaActual(){
		return new java.util.Date();
	}
}
